package com.swiot.biz.service.impl;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.swiot.biz.constants.TemplateConstants;
import com.swiot.biz.domain.DynamicTemplateData;
import com.swiot.biz.domain.Template;
import com.swiot.biz.domain.TemplateData;
import com.swiot.biz.mapper.DynamicTemplateDataMapper;
import com.swiot.biz.mapper.TemplateDataMapper;
import com.swiot.biz.service.ITemplateDataService;
import com.swiot.biz.service.ITemplateService;
import com.swiot.biz.utils.LuckysheetDataParser;
import com.swiot.common.core.domain.entity.SysDept;
import com.swiot.common.exception.ServiceException;
import com.swiot.common.utils.SecurityUtils;
import com.swiot.common.utils.StringUtils;
import com.swiot.system.service.ISysDeptService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;

/**
 * 模板数据Service业务层处理
 *
 * @author kingdom
 * &#064;date  2025-09-04
 */
@Service
public
class TemplateDataServiceImpl implements ITemplateDataService {
    private static final Logger logger = LoggerFactory.getLogger(TemplateDataServiceImpl.class);

    @Autowired
    private TemplateDataMapper templateDataMapper;

    @Autowired
    private DynamicTemplateDataMapper dynamicTemplateDataMapper;

    @Autowired
    private ITemplateService templateService;

    @Autowired
    private ISysDeptService sysDeptService;
    @Autowired
    private LuckysheetDataParser luckysheetDataParser;

    /**
     * 查询模板数据
     *
     * @param id 模板数据主键
     * @return 模板数据
     */
    @Override
    public TemplateData selectTemplateDataById(String id) {
        return templateDataMapper.selectTemplateDataById(id);
    }

    @Override
    public TemplateData selectTemplateDataSimpleById(String id) {
        return templateDataMapper.selectTemplateDataSimpleById(id);
    }

    /**
     * 查询模板数据列表
     *
     * @param templateData 模板数据
     * @return 模板数据
     */
    @Override
    public List<TemplateData> selectTemplateDataList(TemplateData templateData) {
        return templateDataMapper.selectTemplateDataList(templateData);
    }

    /**
     * 查询模板数据列表
     *
     * @param templateData 模板数据
     * @return 模板数据
     */
    @Override
    public List<TemplateData> selectTemplateDataPageList(TemplateData templateData) {
        return templateDataMapper.selectTemplateDataPageList(templateData);
    }

    /**
     * 查询模板数据总和
     *
     * @param templateId 模板ID
     * @param year       年份
     * @return 模板数据总和
     */
    @Override
    public HashMap<String, Object> queryTemplateDataSum(String templateId, String year) {
        if (StringUtils.isBlank(templateId) || StringUtils.isBlank(year)) {
            return null;
        }
        TemplateData templateData = templateDataMapper.selectTemplateById(templateId);
        if (templateData == null) {
            return null;
        }
        DynamicTemplateData dynamicTemplateData = new DynamicTemplateData();
        dynamicTemplateData.setTemplateId(templateData.getTemplateId());
        dynamicTemplateData.setReportDate(StringUtils.substring(year, 0, 4));
        dynamicTemplateData.setTableName(templateData.getTableName());
        JSONArray fieldRowCol = JSONArray.parse(templateData.getFieldRowKey());

        dynamicTemplateData.setFieldRowCol(fieldRowCol.toArray(String.class));
        HashMap<String, Object> templateDataSum = dynamicTemplateDataMapper.selectDynamicTemplateDataSum(dynamicTemplateData);
        if (templateDataSum == null) {
            return null;
        }
        return templateDataSum;
    }

    /**
     * 新增模板数据
     *
     * @param templateData 模板数据
     * @return 结果
     */
    @Override
    public int insertTemplateData(TemplateData templateData) {
        // 检查是否存在相同的模板数据（templateId、reportDate、deptId）
        TemplateData existingData = selectTemplateDataByUnique(
                templateData.getTemplateId(),
                templateData.getReportDate(),
                templateData.getDeptId()
        );
        if (existingData != null) {
            throw new ServiceException("该模板数据已存在，请勿重复添加");
        }

        // 根据templateId查询模板信息
        Template template = templateService.selectTemplateById(templateData.getTemplateId());
        if (template == null) {
            throw new ServiceException(TemplateConstants.ErrorMessages.TEMPLATE_NOT_EXISTS);
        }

        // 根据deptId查询部门信息
        SysDept dept = sysDeptService.selectDeptById(templateData.getDeptId());
        if (dept == null) {
            throw new ServiceException(TemplateConstants.ErrorMessages.DEPT_NOT_EXISTS);
        }

        // 赋值相关字段

        templateData.setTemplateName(template.getTemplateName());
        templateData.setTableName(template.getTemplateTable());
        templateData.setSegmentName(dept.getSegmentName());

        // 处理luckysheet数据内容
//        String processedTemplateContent = processLuckysheetData(template);
        templateData.setTemplateContent(template.getTemplateContent());
        templateData.setTemplateContentView(template.getTemplateContentView());
        templateData.setFieldRowCol(template.getFieldRowCol());
        templateData.setDataRowCol(template.getDataRowCol());
        templateData.setAlarmRowCol(template.getAlarmRowCol());
        templateData.setFieldRowKey(template.getFieldRowKey());
        templateData.setAlarmRowKey(template.getAlarmRowKey());
        templateData.setFieldObject(template.getFieldObject());
        templateData.setDataType(templateData.getReportDate().substring(4, 6));

        templateData.setCreatedTime(new Date());
        templateData.setCreatedById(SecurityUtils.getUserId().toString());
        templateData.setCreatedBy(SecurityUtils.getUsername());

        // 检查templateName是否为空
        if (StringUtils.isEmpty(templateData.getTemplateName())) {
            throw new ServiceException(TemplateConstants.ErrorMessages.TEMPLATE_NAME_EMPTY);
        }

        // 检查tableName是否为空
        if (StringUtils.isEmpty(templateData.getTableName())) {
            throw new ServiceException(TemplateConstants.ErrorMessages.TEMPLATE_TABLE_EMPTY);
        }
        int result = templateDataMapper.insertTemplateData(templateData);
        if (result != 1) {
            throw new ServiceException("新增动态模板数据失败");
        }

        DynamicTemplateData dynamicTemplateData = genDynamicTemplateData(templateData);
        int singleResult = dynamicTemplateDataMapper.insertDynamicTemplateData(dynamicTemplateData);
        if (singleResult != 1) {
            throw new ServiceException("新增动态模板数据失败");
        }


        templateData.setReportDate(templateData.getReportDate().substring(0, 4) + TemplateConstants.DEFAULT_YEAR_SUFFIX);
        Integer count = templateDataMapper.selectTemplateDataCount(templateData);
        if (count < 1) {
            templateData.setId(null);
            templateData.setDataType(TemplateConstants.DataType.YEAR);
            count = templateDataMapper.insertTemplateData(templateData);
            if (count != 1) {
                throw new ServiceException("新增 年度统计失败");
            }
            DynamicTemplateData queryCondition = new DynamicTemplateData();
            queryCondition.setTemplateId(templateData.getTemplateId());
            queryCondition.setReportDate(templateData.getReportDate());
            queryCondition.setDeptId(templateData.getDeptId());
            queryCondition.setTableName(templateData.getTableName());
            count = dynamicTemplateDataMapper.selectDynamicTemplateDataCount(queryCondition);
            if (count < 1) {
                dynamicTemplateData.setReportDate(templateData.getReportDate());
                dynamicTemplateData.setDataType(templateData.getDataType());
                singleResult = dynamicTemplateDataMapper.insertDynamicTemplateData(dynamicTemplateData);
            }
        }

        return singleResult;
    }

    /**
     * 生成动态模板数据
     *
     * @param templateData 模板数据
     * @return 动态模板数据
     */
    private DynamicTemplateData genDynamicTemplateData(TemplateData templateData) {
        DynamicTemplateData dynamicTemplateData = new DynamicTemplateData();
        dynamicTemplateData.setTemplateId(templateData.getTemplateId());
        dynamicTemplateData.setTemplateDataId(templateData.getId());
        dynamicTemplateData.setReportDate(templateData.getReportDate());
        dynamicTemplateData.setDataType(templateData.getDataType());
        dynamicTemplateData.setDeptId(templateData.getDeptId());
        dynamicTemplateData.setDescription(templateData.getDescription());
        dynamicTemplateData.setTableName(templateData.getTableName());
        dynamicTemplateData.setSegmentName(templateData.getSegmentName());
        dynamicTemplateData.setPublishStatus(templateData.getTemplatePublishStatus());
        dynamicTemplateData.setDelFlag("0");
        dynamicTemplateData.setCreatedTime(templateData.getCreatedTime());
        dynamicTemplateData.setCreatedById(templateData.getCreatedById());
        dynamicTemplateData.setCreatedBy(templateData.getCreatedBy());
        return dynamicTemplateData;
    }

    /**
     * 修改模板数据
     *
     * @param templateData 模板数据
     * @return 结果
     */
    @Override
    public int updateTemplateData(TemplateData templateData) {
        // 基础判空检查
        if (templateData == null) {
            throw new ServiceException("模板数据不能为空");
        }

        if (StringUtils.isEmpty(templateData.getId())) {
            throw new ServiceException("模板数据ID不能为空");
        }

        // 检查数据是否存在
        TemplateData existingData = selectTemplateDataById(templateData.getId());
        if (existingData == null) {
            throw new ServiceException("模板数据不存在");
        }

        // 处理luckysheet数据内容，提取字段数组
        if (StringUtils.isEmpty(templateData.getTemplateContentView())) {
            throw new ServiceException("模板数据不存在");
        }

        existingData.setTemplateContentView(templateData.getTemplateContentView());
        existingData.setUpdatedBy(SecurityUtils.getUsername());
        existingData.setUpdatedById(SecurityUtils.getUserId().toString());
        existingData.setUpdatedTime(new Date());

        return templateDataMapper.updateTemplateData(templateData);
    }

    /**
     * 批量删除模板数据
     *
     * @param ids 需要删除的模板数据主键
     * @return 结果
     */
    @Override
    public int deleteTemplateDataByIds(String[] ids) {
        TemplateData templateData = templateDataMapper.selectTemplateDataById(ids[0]);
        if (templateData == null) {
            throw new ServiceException("模板数据不存在");
        }
        dynamicTemplateDataMapper.deleteDynamicTemplateDataByDataId(templateData.getTableName(), templateData.getId());
        return templateDataMapper.deleteTemplateDataByIds(ids);
    }

    /**
     * 删除模板数据信息
     *
     * @param id 模板数据主键
     * @return 结果
     */
    @Override
    public int deleteTemplateDataById(String id) {
        return templateDataMapper.deleteTemplateDataById(id);
    }

    /**
     * 检查是否存在相同的模板数据
     *
     * @param templateId 模板ID
     * @param reportDate 报表日期
     * @param deptId     公司ID
     * @return 模板数据
     */
    @Override
    public TemplateData selectTemplateDataByUnique(String templateId, String reportDate, Long deptId) {
        TemplateData templateData = new TemplateData();
        templateData.setTemplateId(templateId);
        templateData.setReportDate(reportDate);
        templateData.setDeptId(deptId);
        return templateDataMapper.selectTemplateDataByUnique(templateData);
    }

    /**
     * 发布模板数据
     *
     * @param id 模板数据主键
     * @return 结果
     */
    @Override
    public int publishTemplateData(String id) {
        TemplateData templateData = selectTemplateDataById(id);
        if (templateData == null) {
            throw new ServiceException("模板数据不能为空");
        }
        JSONObject fieldsObjects = luckysheetDataParser.extractFieldsObjectsFromLuckysheet(
                templateData.getTemplateContent(),
                Integer.parseInt(templateData.getFieldRowCol().split(TemplateConstants.ROW_COL_SEPARATOR)[0]),
                Integer.parseInt(templateData.getFieldRowCol().split(TemplateConstants.ROW_COL_SEPARATOR)[1]),
                Integer.parseInt(templateData.getDataRowCol().split(TemplateConstants.ROW_COL_SEPARATOR)[1]),
                Integer.parseInt(templateData.getAlarmRowCol().split(TemplateConstants.ROW_COL_SEPARATOR)[1]),
                JSONObject.parseObject(templateData.getFieldObject())
        );
        if (fieldsObjects == null) {
            throw new ServiceException("提取字段对象失败");
        }

        //提取单个模板数据，并更新表
        DynamicTemplateData selectDynamicTemplateDataByDataId = new DynamicTemplateData();
        selectDynamicTemplateDataByDataId.setTemplateDataId(id);
        selectDynamicTemplateDataByDataId.setTableName(templateData.getTableName());
        selectDynamicTemplateDataByDataId.setDataType(templateData.getDataType());
        DynamicTemplateData dynamicTemplateData = dynamicTemplateDataMapper.selectDynamicTemplateDataByDataId(selectDynamicTemplateDataByDataId);
        if (dynamicTemplateData == null) {
            throw new ServiceException("动态模板数据不能为空");
        }
        processTemplateContentFields(templateData, dynamicTemplateData);
        dynamicTemplateData.setPublishStatus(TemplateConstants.PublishStatus.PUBLISHED);
        dynamicTemplateData.setTableName(templateData.getTableName());
        dynamicTemplateData.setUpdatedTime(templateData.getUpdatedTime());
        dynamicTemplateData.setUpdatedById(templateData.getUpdatedById());
        dynamicTemplateData.setUpdatedBy(templateData.getUpdatedBy());
        dynamicTemplateDataMapper.updateDataByTableName(dynamicTemplateData);


        //汇总本年度的模板数据，并更新表，年度汇总数据为 99 结尾
        dynamicTemplateData.setReportDate(templateData.getReportDate().substring(0, 4) + TemplateConstants.DEFAULT_YEAR_SUFFIX);
        dynamicTemplateDataMapper.updateDataByTableName(dynamicTemplateData);


        //更新模板数据为已发布状态
        templateData.setFieldObject(fieldsObjects.toJSONString());
        templateData.setTemplatePublishStatus(TemplateConstants.PublishStatus.PUBLISHED);
        return templateDataMapper.updateTemplateData(templateData);
    }

    /**
     * 撤销模板数据
     *
     * @param id 模板数据主键
     * @return 结果
     */
    @Override
    public int unpublishTemplateData(String id) {
        TemplateData templateData = new TemplateData();
        templateData.setId(id);
        templateData.setTemplatePublishStatus(TemplateConstants.PublishStatus.UNPUBLISHED);
        return templateDataMapper.updateTemplateData(templateData);
    }

    /**
     * 处理luckysheet数据内容
     * 1. 获取指定列（fieldRowCol）的数据对象.val值
     * 2. 在指定列（dataRowCol）的数据对象新增data属性并赋值
     * 3. 删除指定列（fieldRowCol）的数据对象
     *
     * @param template 模板对象
     * @return 处理后的模板内容JSON字符串
     */
    private String processLuckysheetData(Template template) {
        try {
            logger.info("开始处理luckysheet数据内容，模板ID: {}, 字段行列: {}, 数据行列: {}",
                    template.getId(), template.getFieldRowCol(), template.getDataRowCol());

            String templateContent = template.getTemplateContent();
            if (StringUtils.isEmpty(templateContent)) {
                logger.warn("模板内容为空，模板ID: {}", template.getId());
                return templateContent;
            }

            // 解析JSON
            JSONObject jsonData = JSON.parseObject(templateContent);
            logger.debug("原始模板内容: {}", jsonData.toJSONString());

            // 获取data数组
            JSONArray dataArray = jsonData.getJSONArray("data");
            if (dataArray == null || dataArray.isEmpty()) {
                logger.warn("模板数据为空，模板ID: {}", template.getId());
                return templateContent;
            }

            // 获取第一个工作表的数据
            JSONObject firstSheet = dataArray.getJSONObject(0);
            if (firstSheet == null) {
                logger.warn("第一个工作表数据为空，模板ID: {}", template.getId());
                return templateContent;
            }

            // 获取celldata数组
            JSONArray celldataArray = firstSheet.getJSONArray("data");
            if (celldataArray == null || celldataArray.isEmpty()) {
                logger.info("工作表celldata为空，模板ID: {}", template.getId());
                return templateContent;
            }

            // 解析行列信息
            String fieldRowCol = template.getFieldRowCol();
            String dataRowCol = template.getDataRowCol();

            if (StringUtils.isEmpty(fieldRowCol) || StringUtils.isEmpty(dataRowCol)) {
                logger.warn("字段行列或数据行为空，字段行列: {}, 数据行列: {}, 模板ID: {}",
                        fieldRowCol, dataRowCol, template.getId());
                return templateContent;
            }

            // 解析行列坐标
            String[] fieldCoords = fieldRowCol.split(":");
            String[] dataCoords = dataRowCol.split(":");

            if (fieldCoords.length != 2 || dataCoords.length != 2) {
                logger.error("行列坐标格式错误，字段行列: {}, 数据行列: {}, 模板ID: {}",
                        fieldRowCol, dataRowCol, template.getId());
                return templateContent;
            }

            int fieldRow = Integer.parseInt(fieldCoords[0]);
            int fieldCol = Integer.parseInt(fieldCoords[1]);
            int dataRow = Integer.parseInt(dataCoords[0]);
            int dataCol = Integer.parseInt(dataCoords[1]);

            logger.info("解析坐标 - 字段行列: [{}, {}], 数据行列: [{}, {}]",
                    fieldRow, fieldCol, dataRow, dataCol);

            // 查找字段列的数据对象

            for (int i = 0; i < celldataArray.size(); i++) {
                JSONObject cellField = celldataArray.getJSONArray(i + fieldRow).getJSONObject(fieldCol);

                JSONObject cellData = celldataArray.getJSONArray(i + dataRow).getJSONObject(dataCol);
                if (cellData == null) {
                    celldataArray.getJSONArray(i + dataRow).remove(dataCol);
                    celldataArray.getJSONArray(i + dataRow).add(dataCol, getCellData());
                    cellData = celldataArray.getJSONArray(i + dataRow).getJSONObject(dataCol);
                }
                if (cellData == null || cellField == null) continue;

                String cellFieldVal = cellField.getString("v");
                if (cellFieldVal == null) continue;
                cellData.put("field", cellFieldVal);
                celldataArray.getJSONArray(i + fieldRow).remove(fieldCol);
            }

            String result = jsonData.toJSONString();
            logger.info("luckysheet数据处理完成，模板ID: {}", template.getId());
            logger.debug("处理后的模板内容: {}", result);

            return result;

        } catch (Exception e) {
            logger.error("处理luckysheet数据时发生错误，模板ID: {}, 错误信息: {}",
                    template.getId(), e.getMessage(), e);
            // 发生错误时返回原始内容
            return template.getTemplateContent();
        }
    }

    private JSONObject getCellData() {

        JSONObject cellData = new JSONObject();
        cellData.put("v", "");
        JSONObject ct = new JSONObject();
        ct.put("fa", "General");
        ct.put("t", "g");
        cellData.put("ct", ct);
        cellData.put("m", "");

        return cellData;

    }

    /**
     * 处理templateContent内容，提取字段数组
     * 读取cellData数据，获取field字段数组和v字段数组，将字段数组设置到dynamicTemplateData的fieldRowCol和dataRowCol
     * 参考processLuckysheetData的数据结构处理方式
     *
     * @param templateData        模板内容JSON字符串
     * @param dynamicTemplateData 动态模板数据对象
     */
    private void processTemplateContentFields(TemplateData templateData, DynamicTemplateData dynamicTemplateData) {
        try {
            logger.info("开始处理templateContent字段提取");

            if (StringUtils.isEmpty(templateData.getTemplateContent())) {
                logger.warn("模板内容为空");
                return;
            }

            // 解析JSON - 参考processLuckysheetData的方式
            JSONObject jsonData = JSON.parseObject(templateData.getTemplateContent());
//            logger.debug("原始模板内容: {}", jsonData.toJSONString());

            // 获取data数组 - 参考processLuckysheetData的方式
            JSONArray dataArray = jsonData.getJSONArray("data");
            if (dataArray == null || dataArray.isEmpty()) {
                logger.warn("模板数据为空");
                return;
            }

            // 获取第一个工作表的数据 - 参考processLuckysheetData的方式
            JSONObject firstSheet = dataArray.getJSONObject(0);
            if (firstSheet == null) {
                logger.warn("第一个工作表数据为空");
                return;
            }

            // 获取celldata数组 - 参考processLuckysheetData的数据结构
            JSONArray celldataArray = firstSheet.getJSONArray("data");
            if (celldataArray == null || celldataArray.isEmpty()) {
                logger.info("工作表celldata为空");
                return;
            }
            // 解析行列信息
            String fieldRowCol = templateData.getFieldRowCol();
            String dataRowCol = templateData.getDataRowCol();


            // 解析行列坐标
            String[] fieldCoords = fieldRowCol.split(":");
            String[] dataCoords = dataRowCol.split(":");


            int fieldRow = Integer.parseInt(fieldCoords[0]);
            int fieldCol = Integer.parseInt(fieldCoords[1]);
            int dataRow = Integer.parseInt(dataCoords[0]);
            int dataCol = Integer.parseInt(dataCoords[1]);

            logger.info("解析坐标 - 字段行列: [{}, {}], 数据行列: [{}, {}]",
                    fieldRow, fieldCol, dataRow, dataCol);
            // 提取field字段数组和v字段数组
            List<String> fieldArray = new ArrayList<>();
            List<String> valueArray = new ArrayList<>();
            JSONObject fieldObjects = JSONObject.parseObject(templateData.getFieldObject());

            // 参考processLuckysheetData的遍历方式：celldataArray.getJSONArray(i)
            int size = celldataArray.size();
            for (int i = 1; i < size; i++) {
                JSONObject cellField = celldataArray.getJSONArray(i + fieldRow).getJSONObject(fieldCol);
                JSONObject cellData = celldataArray.getJSONArray(i + dataRow).getJSONObject(dataCol);
                if (cellField == null || StringUtils.isBlank(cellField.getString("v"))) continue;
                String cellDataVal = ObjectUtils.isEmpty(cellData) ? "" : cellData.getString("v");

                String value = cellField.getString("v") + " = '" + cellDataVal + "'";
                if (i < size - 1) {
                    value += ",";
                }
                String key = cellField.getString("v").trim();
                if (fieldObjects.containsKey(key)) {
                    fieldObjects.getJSONObject(key).put(value, cellDataVal);
                }
                fieldArray.add(value);
                valueArray.add(cellDataVal);
            }
            dynamicTemplateData.setFieldRowCol(fieldArray.toArray(new String[0]));
            dynamicTemplateData.setDataRowCol(valueArray.toArray(new String[0]));
//            templateData.setFieldObject(fieldObjects.toJSONString());
//            System.out.println("fieldCellData: " + fieldObjects);

        } catch (Exception e) {
            logger.error("处理templateContent字段提取时发生错误，错误信息: {}",
                    e.getMessage(), e);
        }
    }

    private void processTemplateDataFields(TemplateData templateData, DynamicTemplateData dynamicTemplateData) {

    }
}
